home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / putz / putzdo.i < prev    next >
Text File  |  1997-10-26  |  15KB  |  450 lines
  1. IMPLEMENTATION MODULE PutzDo;
  2.  
  3. FROM SYSTEM IMPORT ADDRESS, ADR, CADR, TSIZE, BYTE, ASSEMBLER, CALLSYS;
  4.  
  5.  
  6. (* MM2 *)
  7. FROM Storage            IMPORT ALLOCATE, DEALLOCATE, MemAvail;
  8.  
  9. FROM Lists      IMPORT  List,           CreateList,     DeleteList,
  10.                         AppendEntry,    ListEmpty,      CurrentEntry,
  11.                         NextEntry,      ResetList,      RemoveEntry,
  12.                         ScanEntries,    LDir,           LCondProc,
  13.                         NoOfEntries,    PrevEntry;
  14.  
  15.  
  16. (* MagicLib *)
  17. IMPORT MagicStrings, MagicTypes;
  18.      
  19.         (* magic tools *)
  20. IMPORT mtDials, mtAlerts;
  21.      
  22. (* CatPutz *)
  23.  
  24. FROM PutzTypes          IMPORT grListEntry, ptrGrEntry, defaultOpts, delState,
  25.                                totalEntry, putzList, groupList, displayList,
  26.                                listEntryType, displayListEntry, ptrDispEntry;
  27.  
  28. FROM PutzRsc    IMPORT  menu, ReplaceStr;
  29.      
  30. IMPORT Catputz2;
  31.  
  32. IMPORT PutzLog, PutzTypes, PutzAction, PutzGroup, PutzWindows;
  33.  
  34. (* CAT *)
  35. IMPORT dataSys, ConvertDate, ConfVars, MTPaths;
  36.  
  37. FROM Void   IMPORT v;
  38.  
  39.         (* Operationen auf der Gruppenliste *)
  40.  
  41. PROCEDURE CountSelectedEntries (gr: List): INTEGER;
  42.   VAR count : INTEGER;
  43.       entry : ptrGrEntry;
  44. BEGIN
  45.   count := 0;
  46.   ResetList (gr);
  47.   WHILE NextEntry (gr) # NIL DO
  48.     entry := CurrentEntry (gr);
  49.     IF entry^.selected THEN INC (count); END;
  50.   END;
  51.   RETURN count;
  52. END CountSelectedEntries;
  53.  
  54. PROCEDURE FirstSelectedGroup (gr : List) : ADDRESS;
  55.   VAR entry : ptrGrEntry;
  56. BEGIN
  57.   ResetList (gr);
  58.   WHILE NextEntry (gr) # NIL DO
  59.     entry := CurrentEntry (gr);
  60.     IF entry^.selected THEN RETURN entry END;
  61.   END;
  62.   RETURN NIL
  63. END FirstSelectedGroup;
  64.  
  65. PROCEDURE NextSelectedGroup (gr : List; currentGroup: INTEGER) : ADDRESS;
  66.   VAR entry : ptrGrEntry;
  67.       i     : INTEGER;
  68. BEGIN
  69.   ResetList (gr);
  70.   REPEAT
  71.    entry := NextEntry (gr);
  72.    IF entry # NIL
  73.    THEN
  74.      i := entry^.info^.catNumber
  75.    END;
  76.   UNTIL (i=currentGroup) OR (entry=NIL);
  77.   IF entry = NIL THEN RETURN -1 END;
  78.   WHILE NextEntry (gr) # NIL DO
  79.     entry := CurrentEntry (gr);
  80.     IF entry^.selected THEN RETURN entry END;
  81.   END;
  82.   RETURN NIL
  83. END NextSelectedGroup;
  84.  
  85. PROCEDURE GetGroupEntry (index : INTEGER) : ptrGrEntry;
  86.   CONST emptyName = "  ";
  87.   VAR i : INTEGER;
  88.       entry : ptrGrEntry;
  89. BEGIN
  90.   ResetList (putzList);
  91.   REPEAT
  92.    entry := NextEntry (putzList);
  93.    IF entry # NIL
  94.    THEN
  95.      i := entry^.info^.catNumber
  96.    END;
  97.   UNTIL (i=index) OR (entry=NIL);
  98.   RETURN entry;
  99. END GetGroupEntry;
  100.  
  101. PROCEDURE SelectAll( select : BOOLEAN);
  102.   VAR entry : ptrGrEntry;
  103. BEGIN
  104.   ResetList (putzList);
  105.   WHILE NextEntry (putzList) # NIL DO
  106.     entry := CurrentEntry (putzList);
  107.     IF ~((entry^.info^.catNumber = dataSys.private) & select)
  108.     THEN entry^.selected := select; 
  109.     END;
  110.   END;
  111. END SelectAll;
  112.  
  113. PROCEDURE CalcTotals;
  114.   VAR entry : ptrGrEntry;
  115.   
  116.   PROCEDURE addIt ();
  117.   BEGIN
  118.    WITH entry^ DO
  119.     INC (totalEntry.preMsgs, preMsgs);
  120.     INC (totalEntry.preBytes, preBytes);
  121.     IF postBytes # 0
  122.     THEN
  123.       INC (totalEntry.postBytes, postBytes)
  124.     ELSE
  125.       INC (totalEntry.postBytes, preBytes);
  126.     END;
  127.     IF postMsgs # 0
  128.     THEN
  129.       INC (totalEntry.postMsgs, postMsgs)
  130.     ELSE
  131.       INC (totalEntry.postMsgs, preMsgs);
  132.     END;
  133.     INC (totalEntry.badDel, badDel);
  134.     INC (totalEntry.totalDel, totalDel);
  135.     INC (totalEntry.partDel, partDel);
  136.    END;
  137.   END addIt;
  138.  
  139. BEGIN
  140.   totalEntry.preMsgs := 0;
  141.   totalEntry.preBytes := 0;
  142.   totalEntry.badDel := 0;
  143.   totalEntry.totalDel := 0;
  144.   totalEntry.partDel := 0;
  145.   totalEntry.postMsgs := 0;
  146.   totalEntry.postBytes := 0;
  147. (*  entry := ADR(persGroup); 
  148.   addIt();
  149. *)
  150.   ResetList (putzList);
  151.   entry := NextEntry (putzList);
  152.   WHILE entry # NIL DO
  153.     addIt();
  154.     entry := NextEntry (putzList);
  155.   END;
  156. END CalcTotals;
  157.  
  158. PROCEDURE PerformDelete(wdwHandle: INTEGER);
  159.   VAR i : CARDINAL;
  160.       ch : CHAR;
  161.       oCurrGr : INTEGER;
  162.       currGrEntry : ptrGrEntry;
  163.       rdB : LONGCARD;
  164.       putzOpts  : PutzTypes.putzOptsRec;
  165.       success   : BOOLEAN;
  166. BEGIN
  167.   currGrEntry := FirstSelectedGroup(putzList);
  168.   IF currGrEntry = NIL THEN RETURN END;
  169.   PutzAction.InitActionBox ();
  170.   WHILE currGrEntry # NIL  DO
  171.     putzOpts := InitGroupFlags (currGrEntry^.info^.catNumber, TRUE, success);
  172.     IF ~success THEN 
  173.       PutzAction.ReleaseActionBox();
  174.       RETURN 
  175.     END;
  176.     IF ~PutzGroup.deleteInGroup (currGrEntry, putzOpts, PutzTypes.dFlags)
  177.     THEN
  178.       PutzAction.ReleaseActionBox();
  179.       RETURN 
  180.     END;
  181.     IF PutzWindows.IsPutzWindow (wdwHandle)
  182.     THEN
  183.       CalcTotals();
  184.       IF putzOpts.deselAfterDel
  185.       THEN
  186.         PutzWindows.DeselectEntry (wdwHandle, currGrEntry);
  187.       END;
  188.       PutzWindows.RedrawEntry (wdwHandle, currGrEntry);
  189.       PutzWindows.RedrawEntry (wdwHandle, ADR(totalEntry));
  190.     END;
  191.     (* N„chste Gruppe suchen *)
  192.     currGrEntry := NextSelectedGroup(putzList, currGrEntry^.info^.catNumber);
  193.   END;
  194.   PutzAction.ReleaseActionBox();
  195. END PerformDelete;
  196.  
  197. PROCEDURE InitDelete (wdwHandle: INTEGER);
  198.   VAR currGrEntry: ptrGrEntry;
  199. BEGIN
  200.   currGrEntry := FirstSelectedGroup(putzList);
  201.   IF currGrEntry = NIL THEN RETURN END;
  202.   (* Menu disablen *)
  203.   mtDials.DisableMenu (menu, TRUE);
  204.   (* L”schen durchfhren *)
  205.  
  206.   IF PutzLog.OpenLog (MTPaths.DataPath) THEN END;
  207.   PutzLog.putTime();
  208.   PutzLog.WriteString (PutzTypes.version);
  209.   PutzLog.WriteString (" fr CAT 3.x gestartet");
  210.   PutzLog.WriteLn;
  211.  
  212.   PerformDelete (wdwHandle);
  213.  
  214.   (* Ok, das war's, weiter im normalen Programm *)
  215.   CalcTotals;
  216.   PutzLog.WriteString ("--------------------------------------------------");
  217.   PutzLog.WriteLn;
  218.   PutzLog.putTime ();
  219.   PutzLog.WriteString (" L”schen beendet.");
  220.   PutzLog.WriteLn;
  221.   PutzLog.WriteLine   ("STATISTIK: ");
  222.   PutzLog.WriteString ("           Gesamtanzahl Messages vorher: ");
  223.   PutzLog.WriteCard (totalEntry.preMsgs);
  224.   PutzLog.WriteLn;
  225.   PutzLog.WriteString ("           Gesamtanzahl Messages nachher: ");
  226.   PutzLog.WriteCard (totalEntry.postMsgs);
  227.   PutzLog.WriteLn;
  228.   PutzLog.WriteString ("           Gesamtanzahl totalgel”schter Messages: ");
  229.   PutzLog.WriteCard (totalEntry.totalDel);
  230.   PutzLog.WriteLn;
  231.   PutzLog.WriteString ("           Gesamtanzahl teilgel”schter Messages: ");
  232.   PutzLog.WriteCard (totalEntry.partDel);
  233.   PutzLog.WriteLn;
  234.   PutzLog.WriteString ("           Gesamtanzahl besch„digter Messages: ");
  235.   PutzLog.WriteCard (totalEntry.badDel);
  236.   PutzLog.WriteLn;
  237.   PutzLog.WriteString ("           Gesamtanzahl Bytes vorher: ");
  238.   PutzLog.WriteCard (totalEntry.preBytes);
  239.   PutzLog.WriteLn;
  240.   PutzLog.WriteString ("           Gesamtanzahl Bytes nachher: ");
  241.   PutzLog.WriteCard (totalEntry.postBytes);
  242.   PutzLog.WriteLn;
  243.   PutzLog.WriteLn;
  244.   PutzLog.CloseLog();
  245.  
  246.   (* Menu wiederherstellen *)
  247.   mtDials.DisableMenu (menu, FALSE);
  248. END InitDelete;
  249.  
  250. PROCEDURE InitGroupFlags (groupIndex: INTEGER; doAlts: BOOLEAN; VAR ok: BOOLEAN): PutzTypes.putzOptsRec;
  251.    VAR ptr: ptrGrEntry;
  252.        gName: PutzTypes.groupName;
  253.        varName : PutzTypes.groupName;
  254.        val     : INTEGER;
  255.        boolVal : BOOLEAN;
  256.        delStr  : PutzTypes.groupName;
  257.        putzOpts: PutzTypes.putzOptsRec;
  258. BEGIN
  259.   ptr := GetGroupEntry (groupIndex);
  260.   ok := TRUE;
  261.   IF ptr # NIL
  262.   THEN
  263.     (* Gruppennamen von Leerzeichen befreien *)
  264.     MagicStrings.Assign (ptr^.info^.name^, gName);
  265.     MagicStrings.CAPS (gName);
  266.     ReplaceStr (gName, ' ','_');    (* Spaces durch Underscores ersetzen *)
  267.     (* Variablennamen zusammenbauen *)
  268.     (* Fr Interessant-Flag *)
  269.     MagicStrings.Assign (gName, varName);
  270.     MagicStrings.Append ('.delInteresting', varName);
  271.     ConfVars.GetConfDefInt (varName, val, ORD(defaultOpts.intFlag));
  272.     putzOpts.intFlag := delState (val);
  273.     (* Fr User-Flag 1 *)
  274.     MagicStrings.Assign (gName, varName);
  275.     MagicStrings.Append ('.delUserflag1', varName);
  276.     ConfVars.GetConfDefInt (varName, val, ORD(defaultOpts.usrFlg1));
  277.     putzOpts.usrFlg1 := delState (val);
  278.     (* Fr User-Flag 2 *)
  279.     MagicStrings.Assign (gName, varName);
  280.     MagicStrings.Append ('.delUserflag2', varName);
  281.     ConfVars.GetConfDefInt (varName, val, ORD(defaultOpts.usrFlg2));
  282.     putzOpts.usrFlg2 := delState (val);
  283.     (* Fr Gelesen-Flag *)
  284.     MagicStrings.Assign (gName, varName);
  285.     MagicStrings.Append ('.delRead', varName);
  286.     ConfVars.GetConfDefInt (varName, val, ORD(defaultOpts.readFlg));
  287.     putzOpts.readFlg := delState (val);
  288.     (* Fr Gefiltert-Flag *)
  289.     MagicStrings.Assign (gName, varName);
  290.     MagicStrings.Append ('.delFiltered', varName);
  291.     ConfVars.GetConfDefInt (varName, val, ORD(defaultOpts.filtFlg));
  292.     putzOpts.filtFlg := delState (val);
  293.     (* Fr Ungelesen-Flag *)
  294.     MagicStrings.Assign (gName, varName);
  295.     MagicStrings.Append ('.delUnread', varName);
  296.     ConfVars.GetConfDefInt (varName, val, ORD(defaultOpts.noRdFlg));
  297.     putzOpts.noRdFlg := delState (val);
  298.     (* L”schdatum zusammensetzen *)
  299.     MagicStrings.Assign (gName, varName);
  300.     MagicStrings.Append ('.deleteByDate', varName);
  301.     ConfVars.GetConfDefBool (varName, boolVal, defaultOpts.deleteByDate);
  302.     putzOpts.deleteByDate := boolVal;
  303.     IF boolVal
  304.     THEN
  305.       (* Datum holen *)
  306.       (* L”schdatum zusammensetzen *)
  307.       MagicStrings.Assign (gName, varName);
  308.       MagicStrings.Append ('.deleteDate', varName);
  309.       ConfVars.GetConfDefStr (varName, delStr, defaultOpts.dateStr);
  310.       MagicStrings.Assign (delStr, putzOpts.dateStr);
  311.       IF ConvertDate.DateOk (delStr)
  312.       THEN
  313.         putzOpts.delDate := ConvertDate.StrToDate (delStr);
  314.         IF putzOpts.delDate > ConvertDate.CurrentDate ()
  315.         THEN
  316.           (* Fehlermeldung! *)
  317.           IF doAlts
  318.           THEN 
  319.             v.int := mtAlerts.Alert (1,"[3][CATPUTZ:|Das L”schdatum ist|gr”žer als das Tagesdatum.][[Abbruch]");
  320.           END;
  321.           ok := FALSE;
  322.         END;
  323.       ELSE
  324.         IF doAlts THEN
  325.           v.int := mtAlerts.Alert (1,"[3][CATPUTZ:|Das L”schdatum ist|nicht gltig.][[Abbruch]");
  326.         END;
  327.         ok := FALSE;
  328.       END;
  329.     ELSE
  330.       MagicStrings.Assign ('', putzOpts.dateStr);
  331.     END;
  332.     putzOpts.useTmp := defaultOpts.useTmp;
  333.     putzOpts.tmpLock := defaultOpts.tmpLock;
  334.     putzOpts.deselAfterDel := defaultOpts.deselAfterDel;
  335.     MagicStrings.Assign (defaultOpts.tmpDir, putzOpts.tmpDir);
  336.     putzOpts.delWithoutComm := defaultOpts.delWithoutComm;
  337.   ELSE
  338.     (* Default nehmen *)
  339.     putzOpts := defaultOpts;
  340.   END;
  341.   RETURN putzOpts;
  342. END InitGroupFlags;
  343.  
  344. PROCEDURE SetGroupFlags (groupIndex: INTEGER; REF putzOpts: PutzTypes.putzOptsRec);
  345.    VAR ptr: ptrGrEntry;
  346.        gName: PutzTypes.groupName;
  347.        varName : PutzTypes.groupName;
  348.        val     : INTEGER;
  349.        boolVal : BOOLEAN;
  350.        delStr  : PutzTypes.groupName;
  351. BEGIN
  352.   ptr := GetGroupEntry (groupIndex);
  353.   IF ptr # NIL
  354.   THEN
  355.     (* Gruppennamen von Leerzeichen befreien *)
  356.     MagicStrings.Assign (ptr^.info^.name^, gName);
  357.     MagicStrings.CAPS (gName);
  358.     ReplaceStr (gName, ' ','_');    (* Spaces durch Underscores ersetzen *)
  359.     (* Variablennamen zusammenbauen *)
  360.     (* Fr Interessant-Flag *)
  361.     MagicStrings.Assign (gName, varName);
  362.     MagicStrings.Append ('.delInteresting', varName);
  363.     v.bool := ConfVars.SetConfigInt (varName, ORD(putzOpts.intFlag));
  364.     (* Fr User-Flag 1 *)
  365.     MagicStrings.Assign (gName, varName);
  366.     MagicStrings.Append ('.delUserflag1', varName);
  367.     v.bool := ConfVars.SetConfigInt (varName, ORD(putzOpts.usrFlg1));
  368.     (* Fr User-Flag 2 *)
  369.     MagicStrings.Assign (gName, varName);
  370.     MagicStrings.Append ('.delUserflag2', varName);
  371.     v.bool := ConfVars.SetConfigInt (varName, ORD(putzOpts.usrFlg2));
  372.     (* Fr Gelesen-Flag *)
  373.     MagicStrings.Assign (gName, varName);
  374.     MagicStrings.Append ('.delRead', varName);
  375.     v.bool := ConfVars.SetConfigInt (varName, ORD(putzOpts.readFlg));
  376.     (* Fr Gefiltert-Flag *)
  377.     MagicStrings.Assign (gName, varName);
  378.     MagicStrings.Append ('.delFiltered', varName);
  379.     v.bool := ConfVars.SetConfigInt (varName, ORD(putzOpts.filtFlg));
  380.     (* Fr Ungelesen-Flag *)
  381.     MagicStrings.Assign (gName, varName);
  382.     MagicStrings.Append ('.delUnread', varName);
  383.     v.bool := ConfVars.SetConfigInt (varName, ORD(putzOpts.noRdFlg));
  384.     (* L”schdatum zusammensetzen *)
  385.     MagicStrings.Assign (gName, varName);
  386.     MagicStrings.Append ('.deleteByDate', varName);
  387.     v.bool := ConfVars.SetConfigBool (varName, putzOpts.deleteByDate);
  388.     IF putzOpts.deleteByDate
  389.     THEN
  390.       (* L”schdatum zusammensetzen *)
  391.       MagicStrings.Assign (gName, varName);
  392.       MagicStrings.Append ('.deleteDate', varName);
  393.       v.bool := ConfVars.SetConfigString (varName, putzOpts.dateStr);
  394.     END;
  395.   END;
  396. END SetGroupFlags;
  397.  
  398. PROCEDURE DeleteGroupFlags (groupIndex: INTEGER);
  399.    VAR ptr: ptrGrEntry;
  400.        gName: PutzTypes.groupName;
  401.        varName : PutzTypes.groupName;
  402.        val     : INTEGER;
  403.        boolVal : BOOLEAN;
  404.        delStr  : PutzTypes.groupName;
  405. BEGIN
  406.   ptr := GetGroupEntry (groupIndex);
  407.   IF ptr # NIL
  408.   THEN
  409.     (* Gruppennamen von Leerzeichen befreien *)
  410.     MagicStrings.Assign (ptr^.info^.name^, gName);
  411.     MagicStrings.CAPS (gName);
  412.     ReplaceStr (gName, ' ','_');    (* Spaces durch Underscores ersetzen *)
  413.     (* Variablennamen zusammenbauen *)
  414.     (* Fr Interessant-Flag *)
  415.     MagicStrings.Assign (gName, varName);
  416.     MagicStrings.Append ('.delInteresting', varName);
  417.     ConfVars.DeleteConfigVar (varName);
  418.     (* Fr User-Flag 1 *)
  419.     MagicStrings.Assign (gName, varName);
  420.     MagicStrings.Append ('.delUserflag1', varName);
  421.     ConfVars.DeleteConfigVar (varName);
  422.     (* Fr User-Flag 2 *)
  423.     MagicStrings.Assign (gName, varName);
  424.     MagicStrings.Append ('.delUserflag2', varName);
  425.     ConfVars.DeleteConfigVar (varName);
  426.     (* Fr Gelesen-Flag *)
  427.     MagicStrings.Assign (gName, varName);
  428.     MagicStrings.Append ('.delRead', varName);
  429.     ConfVars.DeleteConfigVar (varName);
  430.     (* Fr Gefiltert-Flag *)
  431.     MagicStrings.Assign (gName, varName);
  432.     MagicStrings.Append ('.delFiltered', varName);
  433.     ConfVars.DeleteConfigVar (varName);
  434.     (* Fr Ungelesen-Flag *)
  435.     MagicStrings.Assign (gName, varName);
  436.     MagicStrings.Append ('.delUnread', varName);
  437.     ConfVars.DeleteConfigVar (varName);
  438.     (* L”schdatum zusammensetzen *)
  439.     MagicStrings.Assign (gName, varName);
  440.     MagicStrings.Append ('.deleteByDate', varName);
  441.     ConfVars.DeleteConfigVar (varName);
  442.     (* L”schdatum zusammensetzen *)
  443.     MagicStrings.Assign (gName, varName);
  444.     MagicStrings.Append ('.deleteDate', varName);
  445.     ConfVars.DeleteConfigVar (varName);
  446.   END;
  447. END DeleteGroupFlags;
  448.  
  449. END PutzDo.
  450.